/**
 * 设备分类数据本地存储管理工具
 */

const CATEGORY_STORAGE_KEY = 'device_categories'
const CATEGORY_MAP_KEY = 'device_categories_map'

/**
 * 分类数据管理类
 */
class CategoryStorage {
  
  /**
   * 设置分类数据到localStorage
   * @param {Array} categories 分类树数据
   */
  setCategoriesData(categories) {
    try {
      console.log('开始存储分类数据:', categories)
      
      // 存储原始树形数据
      localStorage.setItem(CATEGORY_STORAGE_KEY, JSON.stringify(categories))
      
      // 构建分类ID到名称的映射表
      const categoryMap = this.buildCategoryMap(categories)
      localStorage.setItem(CATEGORY_MAP_KEY, JSON.stringify(categoryMap))
      
      console.log('分类数据已存储到localStorage')
      console.log('分类映射表:', categoryMap)
      console.log('映射表大小:', Object.keys(categoryMap).length)
    } catch (error) {
      console.error('存储分类数据失败:', error)
    }
  }
  
  /**
   * 从localStorage获取分类树数据
   * @returns {Array} 分类树数据
   */
  getCategoriesData() {
    try {
      const data = localStorage.getItem(CATEGORY_STORAGE_KEY)
      return data ? JSON.parse(data) : []
    } catch (error) {
      console.error('获取分类数据失败:', error)
      return []
    }
  }
  
  /**
   * 从localStorage获取分类映射表
   * @returns {Object} 分类ID到名称的映射
   */
  getCategoryMap() {
    try {
      const data = localStorage.getItem(CATEGORY_MAP_KEY)
      return data ? JSON.parse(data) : {}
    } catch (error) {
      console.error('获取分类映射表失败:', error)
      return {}
    }
  }
  
  /**
   * 根据分类ID获取分类名称
   * @param {Number|String} categoryId 分类ID
   * @returns {String} 分类名称
   */
  getCategoryName(categoryId) {
    if (!categoryId) return '-'
    
    const categoryMap = this.getCategoryMap()
    
    // 调试信息
    if (Object.keys(categoryMap).length === 0) {
      console.warn('分类映射表为空，可能分类数据还未加载完成')
    }
    
    const categoryName = categoryMap[categoryId]
    if (!categoryName) {
      console.warn(`未找到分类ID ${categoryId} 对应的分类名称，当前映射表:`, categoryMap)
      return `未知分类(${categoryId})`
    }
    
    return categoryName
  }
  
  /**
   * 根据分类ID获取完整分类路径名称
   * @param {Number|String} categoryId 分类ID
   * @returns {String} 完整分类路径，如：数码电子 > 手机 > 智能手机
   */
  getCategoryPath(categoryId) {
    if (!categoryId) return '-'
    
    const categories = this.getCategoriesData()
    const path = this.findCategoryPath(categories, categoryId)
    return path.length > 0 ? path.join(' > ') : this.getCategoryName(categoryId)
  }
  
  /**
   * 构建分类ID到名称的映射表
   * @param {Array} categories 分类树数据
   * @returns {Object} 映射表
   */
  buildCategoryMap(categories) {
    const map = {}
    
    const traverse = (items) => {
      if (!Array.isArray(items)) return
      
      items.forEach(item => {
        if (item.categoryId && item.categoryName) {
          map[item.categoryId] = item.categoryName
        }
        
        // 递归处理子分类
        if (item.children && item.children.length > 0) {
          traverse(item.children)
        }
      })
    }
    
    traverse(categories)
    return map
  }
  
  /**
   * 查找分类的完整路径
   * @param {Array} categories 分类树数据
   * @param {Number|String} targetId 目标分类ID
   * @param {Array} currentPath 当前路径
   * @returns {Array} 分类名称路径数组
   */
  findCategoryPath(categories, targetId, currentPath = []) {
    if (!Array.isArray(categories)) return []
    
    for (const category of categories) {
      const newPath = [...currentPath, category.categoryName]
      
      if (category.categoryId == targetId) {
        return newPath
      }
      
      if (category.children && category.children.length > 0) {
        const result = this.findCategoryPath(category.children, targetId, newPath)
        if (result.length > 0) {
          return result
        }
      }
    }
    
    return []
  }
  
  /**
   * 清除分类数据缓存
   */
  clearCategoriesData() {
    try {
      localStorage.removeItem(CATEGORY_STORAGE_KEY)
      localStorage.removeItem(CATEGORY_MAP_KEY)
      console.log('分类数据缓存已清除')
    } catch (error) {
      console.error('清除分类数据缓存失败:', error)
    }
  }
  
  /**
   * 检查分类数据是否存在
   * @returns {Boolean} 是否存在分类数据
   */
  hasCategoriesData() {
    const data = localStorage.getItem(CATEGORY_STORAGE_KEY)
    return !!(data && data !== 'null' && data !== '[]')
  }
}

// 创建单例实例
const categoryStorage = new CategoryStorage()

export default categoryStorage
